home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic Source Code / Visual Basic Source Code.iso / vbsource / vbdatabs / terminal.cpp < prev    next >
C/C++ Source or Header  |  1999-03-14  |  16KB  |  716 lines
  1. // ------------------------------- //
  2. // -------- Start of File -------- //
  3. // ------------------------------- //
  4. // ----------------------------------------------------------- // 
  5. // C++ Source Code File Name: terminal.cpp
  6. // Compiler Used: MSVC40, DJGPP 2.7.2.1, GCC 2.7.2.1, HP CPP 10.24
  7. // Produced By: Doug Gaer    
  8. // File Creation Date: 03/21/1997 
  9. // Date Last Modified: 03/15/1999
  10. // Copyright (c) 1997 Douglas M. Gaer
  11. // ----------------------------------------------------------- // 
  12. // ------------- Program Description and Details ------------- // 
  13. // ----------------------------------------------------------- // 
  14. /*
  15. The VBD C++ classes are copyright (c) 1997, by Douglas M. Gaer.
  16. All those who put this code or its derivatives in a commercial
  17. product MUST mention this copyright in their documentation for
  18. users of the products in which this code or its derivative
  19. classes are used. Otherwise, you have the freedom to redistribute
  20. verbatim copies of this source code, adapt it to your specific
  21. needs, or improve the code and release your improvements to the
  22. public provided that the modified files carry prominent notices
  23. stating that you changed the files and the date of any change.
  24.  
  25. THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND.
  26. THE ENTIRE RISK OF THE QUALITY AND PERFORMANCE OF THIS SOFTWARE
  27. IS WITH YOU. SHOULD ANY ELEMENT OF THIS SOFTWARE PROVE DEFECTIVE,
  28. YOU WILL ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR, OR
  29. CORRECTION.
  30.  
  31. This is a terminal interface designed to be portable between
  32. DOS and UNIX systems. On UNIX systems the "curses" library is
  33. used to create terminal independent code. On MSDOS/Windows95
  34. systems the ANSI.SYS driver is used to simulate the basic
  35. functions of the "curses" library.
  36. */
  37. // ----------------------------------------------------------- // 
  38. #include <ctype.h>
  39. #include <string.h>
  40. #include "terminal.h"
  41.  
  42. #ifdef __DOS__
  43. #include <iostream.h>
  44. #include <iomanip.h>
  45. #endif
  46.  
  47. #ifdef __UNIX__
  48. #include <sys/time.h>
  49. #include <termio.h>
  50. #endif
  51.  
  52. Terminal I_TERM;              // Independent Teminal type object
  53. Terminal *terminal = &I_TERM; // Global terminal pointer
  54.  
  55. void Terminal::GetString (char *string, int x, int y)
  56. // This function allows the user to enter a single string.
  57. // It was added to echo each character without having to
  58. // to turn the echo on. This will allow the uesr to edit
  59. // the entry using the backspace or other defined keys.
  60. {
  61.   char ch;
  62.   int charcount = 0;
  63.   
  64.   if (x != -1) move (y, x);
  65.  
  66.   while (1) {
  67.     ch = getch();
  68.     if (ch == '\n' || ch == '\r' || ch == CONTROL('c')) {
  69.       *string = 0;
  70.       return;
  71.     }
  72.  
  73.     if (ch == '\b' || ch == CONTROL('d')) { // Delete keys 
  74.       if (charcount > 0) {
  75.     string--;
  76.     charcount--;
  77.     Write('\b');
  78.     Write(' ');
  79.     Write('\b');
  80.       }
  81.     }
  82.     else {
  83.       *string++ = ch;
  84.       charcount++;
  85.       Write(ch);
  86.     }
  87.     refresh();
  88.   }
  89. }
  90.  
  91. void Terminal::GetPassword (char *string, int x, int y)
  92. // This function allows the user to enter a password
  93. // and echo an asterisk for each character typed.
  94. {
  95.   char ch;
  96.   int charcount = 0;
  97.   
  98.   if (x != -1) move (y, x);
  99.  
  100.   while (1) {
  101.     ch = getch();
  102.     if (ch == '\n' || ch == '\r' || ch == CONTROL('c')) {
  103.       *string = 0;
  104.       return;
  105.     }
  106.  
  107.     if (ch == '\b' || ch == CONTROL('d')) { // Delete keys 
  108.       if (charcount > 0) {
  109.     string--;
  110.     charcount--;
  111.     Write('\b');
  112.     Write(' ');
  113.     Write('\b');
  114.       }
  115.     }
  116.     else {
  117.       *string++ = ch;
  118.       charcount++;
  119.       Write('*');
  120.     }
  121.     refresh();
  122.   }
  123. }
  124.  
  125. int Terminal::GetInt(int x, int y)
  126. // Get a signed int value.
  127. {
  128.   char buf[100];
  129.   GetString(buf, x, y);
  130.   return atoi(buf);
  131. }
  132.  
  133. long Terminal::GetLong(int x, int y)
  134. // Get a signed long value.
  135. {
  136.   char buf[100];
  137.   GetString(buf, x, y);
  138.   return atol(buf);
  139. }
  140.  
  141. double Terminal::GetFloat(int x, int y)
  142. // Get a floating point value
  143. {
  144.   char buf[100];
  145.   GetString(buf, x, y);
  146.   return atof(buf);
  147. }
  148.  
  149. int Terminal::YesNo(int x, int y)
  150. {
  151.   if(x == -1) 
  152.     Write(" <Do you wish to continue (y/n)> "); // Same line message
  153.   else
  154.     Write("Do you wish to continue (y/n)...", x, y);
  155.  
  156.   char c = ' ';
  157.   while (c != 'y' && c != 'n')    {
  158.     c = GetChar();
  159.     c = tolower(c);
  160.   }
  161.   return c == 'y' ? 1: 0; // return true if users answers yes
  162. }
  163.  
  164. int Terminal::YesNo(const char *s, int x, int y)
  165. {
  166.   if(x == -1) 
  167.     Write(s); // Same line message
  168.   else
  169.     Write(s, x, y);
  170.  
  171.   char c = ' ';
  172.   while (c != 'y' && c != 'n')    {
  173.     c = GetChar();
  174.     c = tolower(c);
  175.   }
  176.   return c == 'y' ? 1: 0; // return true if users answers yes
  177. }
  178.  
  179. int Terminal::GetYesNo()
  180. // Wait for y/n reply with no prompt.
  181. {
  182.   char c = ' ';
  183.   while (c != 'y' && c != 'n')    {
  184.     c = GetChar();
  185.     c = tolower(c);
  186.   }
  187.   return c == 'y' ? 1: 0; // return true if users answers yes
  188. }
  189.  
  190. void Terminal::PutBack(char c)
  191. // Put back a keyboard character
  192. {
  193.   putback = c;
  194. }
  195.  
  196. int Terminal::Center(const char *s) const
  197. // Returns the center coordinate for a string.
  198. {
  199.   int len = strlen(s);
  200.   if(len > MaxCols()-1) len = MaxCols()-1;
  201.   int mid = MaxCols()/2 - 1;
  202.   int half = len/2;
  203.   return mid - half;
  204. }
  205.  
  206. int Terminal::Center(char *s)
  207. // Returns the center coordinate for a string.
  208. {
  209.   int len = strlen(s);
  210.   if(len > MaxCols()-1) len = MaxCols()-1;
  211.   int mid = MaxCols()/2 - 1;
  212.   int half = len/2;
  213.   return mid - half;
  214. }
  215.  
  216. int Terminal::ScreenCenter(const int offset) const
  217. // Returns the center coordinate for the screen.
  218. {
  219.   int buf = offset;
  220.   if(buf > MaxLines()-1) buf = MaxLines()-1;
  221.   int mid = MaxLines()/2 - 1;
  222.   int half = buf/2;
  223.   return mid - half;
  224. }
  225.  
  226. int Terminal::ScreenCenter(int offset)
  227. // Returns the center coordinate for the screen.
  228. {
  229.   if(offset > MaxLines()-1) offset = MaxLines()-1;
  230.   int mid = MaxLines()/2 - 1;
  231.   int half = offset/2;
  232.   return mid - half;
  233. }
  234.  
  235. int Terminal::Right(const char *s) const
  236. // Returns the right justifed coordinate for a string.
  237. {
  238.   int len = strlen(s);
  239.   if(len > MaxCols()-1) len = MaxCols()-1;
  240.   int end = MaxCols()-1;
  241.   return end - len;
  242. }
  243.  
  244. int Terminal::Right(char *s)
  245. // Returns the right justifed coordinate for a string.
  246. {
  247.   int len = strlen(s);
  248.   if(len > MaxCols()-1) len = MaxCols()-1;
  249.   int end = MaxCols()-1;
  250.   return end - len;
  251. }
  252.  
  253. void Terminal::StatusLine(const char *s) const
  254. // Display a status line in normal text mode.
  255. {
  256.   Write(s, 0, MaxLines()-1);
  257.   int len = strlen(s);
  258.   while (len++ < MaxCols()-1) Write(' ');
  259. }
  260.  
  261. void Terminal::StatusLine(char *s) 
  262. // Display a status line in normal text mode.
  263. {
  264.   Write(s, 0, MaxLines()-1);
  265.   int len = strlen(s);
  266.   while (len++ < MaxCols()-1) Write(' ');
  267. }
  268.  
  269. void Terminal::ClearLine(int x, int y) const
  270. {
  271.   int i = 0;
  272.   if(x == -1) 
  273.     while (i++ < MaxCols()-1) Write(' ');
  274.   else {
  275.     MoveCursor(x, y);
  276.     while (i++ < MaxCols()-1) Write(' ');
  277.   }
  278. }
  279.  
  280. void Terminal::ClearLine(int x, int y)
  281. {
  282.   int i = 0;
  283.   if(x == -1) 
  284.     while (i++ < MaxCols()-1) Write(' ');
  285.   else {
  286.     MoveCursor(x, y);
  287.     while (i++ < MaxCols()-1) Write(' ');
  288.   }
  289. }
  290.  
  291. void Terminal::MoveCursor(int x, int y) const
  292. {
  293.   move(y, x);
  294.   refresh();
  295. }
  296.  
  297. void Terminal::MoveCursor(int x, int y)
  298. {
  299.   move(y, x);
  300.   refresh();
  301. }
  302.  
  303. void Terminal::ClearScreen() const
  304. {
  305.   clear();
  306. }
  307.  
  308. void Terminal::ClearScreen() 
  309. {
  310.   clear();
  311. }
  312.  
  313. void Terminal::AnyKey(int x, int y) 
  314. // Prompt the user for any key to continue
  315. {
  316.   if(x == -1) {
  317.     Write(" <Press any key to continue> "); // Same line message
  318.     GetChar();
  319.     return;
  320.   }
  321.   Write("Press any key to continue...", x, y);
  322.   GetChar();
  323. }
  324.  
  325. void Terminal::AnyKey(const char *s, int x, int y) 
  326. // Prompt the user for any key to continue
  327. {
  328.   if(x == -1) {
  329.     Write(s); // Same line message
  330.     GetChar();
  331.     return;
  332.   }
  333.   Write(s, x, y);
  334.   GetChar();
  335. }
  336.  
  337. void Terminal::Write(const unsigned char c, int x, int y) const
  338. // Write a unsigned character to the screen.
  339. {
  340.   if (x != -1) move (y, x);
  341.   char s[1];
  342.   s[0] = c;    // Copy char into a string buffer
  343.   s[1] = '\0'; // Null term